this._authPrompt.cancel();
}
- addCharacter(unichar) {
+ addCharacter(_unichar) {
// Don't allow type ahead at the login screen
}
});
}
- _oVirtUserAuthenticated(token) {
+ _oVirtUserAuthenticated(_token) {
this._preemptingService = OVIRT_SERVICE_NAME;
this.emit('ovirt-user-authenticated');
}
this.emit('request-surrounding');
}
- _onCommitText(context, text) {
+ _onCommitText(_context, text) {
this.commit(text.get_text());
}
this.delete_surrounding();
}
- _onUpdatePreeditText(context, text, pos, visible) {
+ _onUpdatePreeditText(_context, text, pos, visible) {
if (text == null)
return;
this._preeditVisible = false;
}
- _onForwardKeyEvent(context, keyval, keycode, state) {
+ _onForwardKeyEvent(_context, keyval, keycode, state) {
let press = (state & IBus.ModifierType.RELEASE_MASK) == 0;
state &= ~(IBus.ModifierType.RELEASE_MASK);
Signals.addSignalMethods(LoginManagerSystemd.prototype);
var LoginManagerDummy = class {
- getCurrentSessionProxy(callback) {
+ getCurrentSessionProxy(_callback) {
// we could return a DummySession object that fakes whatever callers
// expect (at the time of writing: connect() and connectSignal()
// methods), but just never calling the callback should be safer
this.signal_quality = quality;
this.emit('notify::signal-quality');
});
- this._proxy.connectSignal('RegistrationInfo', (proxy, sender, [status, code, name]) => {
+ this._proxy.connectSignal('RegistrationInfo', (proxy, sender, [_status, code, name]) => {
this.operator_name = _findProviderForMccMnc(name, code);
this.emit('notify::operator-name');
});
overviewFrames = 0;
}
-function script_overviewShowDone(time) {
+function script_overviewShowDone(_time) {
// We've set up the state at the end of the zoom out, but we
// need to wait for one more frame to paint before we count
// ourselves as done.
METRICS.applicationsShowTimeSubsequent.value = time - applicationsShowStart;
}
-function script_afterShowHide(time) {
+function script_afterShowHide(_time) {
if (overviewShowCount == 1) {
METRICS.usedAfterOverview.value = mallocUsedSize;
} else {
METRICS.applicationsShowTime.value = time - applicationsShowStart;
}
-function script_mainViewDrawStart(time) {
+function script_mainViewDrawStart(_time) {
redrawTiming = 'mainView';
}
-function script_mainViewDrawDone(time) {
+function script_mainViewDrawDone(_time) {
redrawTiming = null;
}
-function script_overviewDrawStart(time) {
+function script_overviewDrawStart(_time) {
redrawTiming = 'overview';
}
-function script_overviewDrawDone(time) {
+function script_overviewDrawDone(_time) {
redrawTiming = null;
}
-function script_redrawTestStart(time) {
+function script_redrawTestStart(_time) {
redrawTiming = 'application';
}
-function script_redrawTestDone(time) {
+function script_redrawTestDone(_time) {
redrawTiming = null;
}
-function script_collectTimings(time) {
+function script_collectTimings(_time) {
for (let timing in redrawTimes) {
let times = redrawTimes[timing];
times.sort((a, b) => a - b);
this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.INSECURE);
}
- _onLoadFailedWithTlsErrors(view, failingURI, certificate, errors) {
+ _onLoadFailedWithTlsErrors(view, failingURI, certificate, _errors) {
this._headerBar.setSecurityIcon(PortalHelperSecurityLevel.INSECURE);
let uri = new Soup.URI(failingURI);
this._webContext.allow_tls_certificate_for_host(certificate, uri.get_host());
this._requestExported = this._request.export(connection, this._handle);
}
- CloseAsync(invocation, params) {
+ CloseAsync(invocation, _params) {
if (this._invocation.get_sender() != invocation.get_sender()) {
invocation.return_error_literal(Gio.DBusError,
Gio.DBusError.ACCESS_DENIED,
'item-removed': { param_types: [GObject.TYPE_INT] },
'item-highlighted': { param_types: [GObject.TYPE_INT] } },
}, class CyclerList extends St.Widget {
- highlight(index, justOutline) {
+ highlight(index, _justOutline) {
this.emit('item-highlighted', index);
}
});
});
}
- _highlightItem(index, justOutline) {
+ _highlightItem(index, _justOutline) {
this._highlight.window = this._items[index];
global.window_group.set_child_above_sibling(this._highlight.actor, null);
}
this._allItems = [];
}
- _childFocused(actor) {
+ _childFocused(_actor) {
// Nothing by default
}
return results.slice(0, maxNumber);
}
- getInitialResultSet(terms, callback, cancellable) {
+ getInitialResultSet(terms, callback, _cancellable) {
let query = terms.join(' ');
let groups = Shell.AppSystem.search(query);
let usage = Shell.AppUsage.get_default();
return item;
}
- popup(activatingButton) {
+ popup(_activatingButton) {
this._redisplay();
this.open();
}
return this._maxValue;
}
- _setCurrentValue(actor, value) {
+ _setCurrentValue(_actor, value) {
this._value = value;
}
destroy() {
}
- requestRange(begin, end) {
+ requestRange(_begin, _end) {
}
- getEvents(begin, end) {
+ getEvents(_begin, _end) {
let result = [];
return result;
}
- hasEvents(day) {
+ hasEvents(_day) {
return false;
}
};
this._loadEvents(false);
}
- _onEventsReceived(results, error) {
+ _onEventsReceived(results, _error) {
let newEvents = [];
let appointments = results[0] || [];
for (let n = 0; n < appointments.length; n++) {
return this.notification.source.createIcon(MESSAGE_ICON_SIZE);
}
- _onUpdated(n, clear) {
+ _onUpdated(n, _clear) {
this.setIcon(this._getIcon());
this.setTitle(n.title);
this.setBody(n.bannerBodyText);
}
}
- _InhibitorsChanged(object, senderName, [inhibtor]) {
+ _InhibitorsChanged(_object, _senderName, [_inhibitor]) {
this._session.IsInhibitedRemote(GNOME_SESSION_AUTOMOUNT_INHIBIT,
(result, error) => {
if (!error) {
return true;
}
- _getWirelessSecrets(secrets, wirelessSetting) {
+ _getWirelessSecrets(secrets, _wirelessSetting) {
let wirelessSecuritySetting = this._connection.get_setting_wireless_security();
if (this._settingName == '802-1x') {
this._destroyed = true;
}
- _vpnChildFinished(pid, status, requestObj) {
+ _vpnChildFinished(pid, status, _requestObj) {
this._childWatch = 0;
if (this._newStylePlugin) {
// For new style plugin, all work is done in the async reading functions
this._currentDialog.performAuthentication();
}
- _onCancel(nativeAgent) {
+ _onCancel(_nativeAgent) {
this._completeRequest(false);
}
- _onDialogDone(dialog, dismissed) {
+ _onDialogDone(_dialog, dismissed) {
this._completeRequest(dismissed);
}
context.accept();
}
- _delegatedChannelsCb(client, channels) {
+ _delegatedChannelsCb(_client, _channels) {
// Nothing to do as we don't make a distinction between observed and
// handled channels.
}
// This is called for both messages we send from
// our client and other clients as well.
- _messageSent(channel, message, flags, token) {
+ _messageSent(channel, message, _flags, _token) {
this._ensureNotification();
message = makeMessageFromTpMessage(message, NotificationDirection.SENT);
this._notification.appendMessage(message);
}
}
- _presenceChanged(contact, presence, status, message) {
+ _presenceChanged(_contact, _presence, _status, _message) {
if (this._notification)
this._notification.update(this._notification.title,
this._notification.bannerBodyText,
this.setLabelText(_("Show Applications"));
}
- handleDragOver(source, actor, x, y, time) {
+ handleDragOver(source, _actor, _x, _y, _time) {
if (!this._canRemoveApp(getAppFromSource(source)))
return DND.DragMotionResult.NO_DROP;
return DND.DragMotionResult.MOVE_DROP;
}
- acceptDrop(source, actor, x, y, time) {
+ acceptDrop(source, _actor, _x, _y, _time) {
let app = getAppFromSource(source);
if (!this._canRemoveApp(app))
return false;
}
}
- handleDragOver(source, actor, x, y, time) {
+ handleDragOver(source, actor, x, y, _time) {
let app = getAppFromSource(source);
// Don't allow favoriting of transient apps
}
// Draggable target interface
- acceptDrop(source, actor, x, y, time) {
+ acceptDrop(source, _actor, _x, _y, _time) {
let app = getAppFromSource(source);
// Don't allow favoriting of transient apps
return global.display.get_monitor_geometry(monitorIndex);
}
- vfunc_gesture_prepare(actor) {
+ vfunc_gesture_prepare(_actor) {
if (this.get_n_current_points() == 0)
return false;
(this._side == St.Side.BOTTOM && y > monitorRect.y + monitorRect.height - EDGE_THRESHOLD));
}
- vfunc_gesture_progress(actor) {
+ vfunc_gesture_progress(_actor) {
let [startX, startY] = this.get_press_coords(0);
let [x, y] = this.get_motion_coords(0);
let offsetX = Math.abs (x - startX);
return true;
}
- vfunc_gesture_end(actor) {
+ vfunc_gesture_end(_actor) {
let [startX, startY] = this.get_press_coords(0);
let [x, y] = this.get_motion_coords(0);
let monitorRect = this._getMonitorRect(startX, startY);
});
}
- Close(parameters, invocation) {
+ Close(_parameters, _invocation) {
this.close();
}
});
this._preeditText.hide();
this._updateVisibility();
});
- panelService.connect('update-auxiliary-text', (ps, text, visible) => {
+ panelService.connect('update-auxiliary-text', (_ps, text, visible) => {
this._auxText.visible = visible;
this._updateVisibility();
this._auxText.hide();
this._updateVisibility();
});
- panelService.connect('update-lookup-table', (ps, lookupTable, visible) => {
+ panelService.connect('update-lookup-table', (_ps, lookupTable, visible) => {
this._candidateArea.actor.visible = visible;
this._updateVisibility();
this._iconThemeChangedId = cache.connect('icon-theme-changed', this._onIconThemeChanged.bind(this));
}
- vfunc_get_preferred_width(forHeight) {
+ vfunc_get_preferred_width(_forHeight) {
// Return the actual height to keep the squared aspect
return this.get_preferred_height(-1);
}
// This can be overridden by a subclass, or by the createIcon
// parameter to _init()
- createIcon(size) {
+ createIcon(_size) {
throw new GObject.NotImplementedError(`createIcon in ${this.constructor.name}`);
}
child.disconnect(child._iconGridKeyFocusInId);
}
- vfunc_get_preferred_width(forHeight) {
+ vfunc_get_preferred_width(_forHeight) {
if (this._fillParent)
// Ignore all size requests of children and request a size of 0;
// later we'll allocate as many children as fit the parent
this._childrenPerPage = 0;
}
- vfunc_get_preferred_height(forWidth) {
+ vfunc_get_preferred_height(_forWidth) {
let height = (this._availableHeightPerPageForItems() + this.bottomPadding + this.topPadding) * this._nPages + this._spaceBetweenPages * this._nPages;
return [height, height];
}
}
}
});
- button.connect('released', (actor, keyval, str) => {
+ button.connect('released', (actor, keyval, _str) => {
if (keyval != 0) {
if (button._keyvalPress)
this._keyboardController.keyvalRelease(keyval);
this.emit('groups-changed');
}
- _onSourceChanged(inputSourceManager, oldSource) {
+ _onSourceChanged(inputSourceManager, _oldSource) {
let source = inputSourceManager.currentSource;
this._currentSource = source;
this.emit('active-group', source.id);
const UiActor = GObject.registerClass(
class UiActor extends St.Widget {
- vfunc_get_preferred_width (forHeight) {
+ vfunc_get_preferred_width (_forHeight) {
let width = global.stage.width;
return [width, width];
}
- vfunc_get_preferred_height (forWidth) {
+ vfunc_get_preferred_height (_forWidth) {
let height = global.stage.height;
return [height, height];
}
}
}
- handleDragOver(source, actor, x, y, time) {
+ handleDragOver(source, _actor, _x, _y, _time) {
if (source != Main.xdndHandler)
return DND.DragMotionResult.CONTINUE;
this._barrierEvents = this._barrierEvents.slice(firstNewEvent);
}
- _onBarrierLeft(barrier, event) {
+ _onBarrierLeft(barrier, _event) {
barrier._isHit = false;
if (this._barriers.every(b => !b._isHit)) {
this._reset();
this._extensions = new Extensions(this);
notebook.appendPage('Extensions', this._extensions.actor);
- this._entry.clutter_text.connect('activate', (o, e) => {
+ this._entry.clutter_text.connect('activate', (o, _e) => {
// Hide any completions we are currently showing
this._hideCompletions();
var MessageTray = class MessageTray {
constructor() {
- this._presence = new GnomeSession.Presence((proxy, error) => {
+ this._presence = new GnomeSession.Presence((proxy, _error) => {
this._onStatusChanged(proxy.status);
});
this._busy = false;
this.emit('windows-restacked', stackIndices);
}
- beginItemDrag(source) {
+ beginItemDrag(_source) {
this.emit('item-drag-begin');
this._inItemDrag = true;
}
- cancelledItemDrag(source) {
+ cancelledItemDrag(_source) {
this.emit('item-drag-cancelled');
}
- endItemDrag(source) {
+ endItemDrag(_source) {
if (!this._inItemDrag)
return;
this.emit('item-drag-end');
this._xdndTimeOut = 0;
}
- handleDragOver(source, actor, x, y, time) {
+ handleDragOver(source, _actor, _x, _y, _time) {
if (source != Main.xdndHandler)
return DND.DragMotionResult.CONTINUE;
if (this._xdndTimeOut != 0)
Mainloop.source_remove(this._xdndTimeOut);
this._xdndTimeOut = Mainloop.timeout_add(BUTTON_DND_ACTIVATION_TIMEOUT, () => {
- this._xdndToggleOverview(actor);
+ this._xdndToggleOverview();
});
GLib.Source.set_name_by_id(this._xdndTimeOut, '[gnome-shell] this._xdndToggleOverview');
this._updatePanel();
}
- vfunc_get_preferred_width(forHeight) {
+ vfunc_get_preferred_width(_forHeight) {
let primaryMonitor = Main.layoutManager.primaryMonitor;
if (primaryMonitor)
this._natHPadding = themeNode.get_length('-natural-hpadding');
}
- vfunc_get_preferred_width(forHeight) {
+ vfunc_get_preferred_width(_forHeight) {
let child = this.get_first_child();
let minimumSize, naturalSize;
return [minimumSize, naturalSize];
}
- vfunc_get_preferred_height(forWidth) {
+ vfunc_get_preferred_height(_forWidth) {
let child = this.get_first_child();
if (child)
menuItem.actor.grab_key_focus();
}
});
- menuItem._activateId = menuItem.connect_after('activate', (menuItem, event) => {
+ menuItem._activateId = menuItem.connect_after('activate', (menuItem, _event) => {
this.emit('activate', menuItem);
this.itemActivated(BoxPointer.PopupAnimation.FULL);
});
this.proxy.ActivateResultRemote(id);
}
- launchSearch(terms) {
+ launchSearch(_terms) {
// the provider is not compatible with the new version of the interface, launch
// the app itself but warn so we can catch the error in logs
log(`Search provider ${this.appInfo.get_id()} does not implement LaunchSearch`);
return true;
}
- _onDragEnd(action, actor, eventX, eventY, modifiers) {
+ _onDragEnd(_action, _actor, _eventX, _eventY, _modifiers) {
if (this._lockScreenState != MessageTray.State.HIDING)
return;
if (this._lockScreenGroup.y < -(ARROW_DRAG_THRESHOLD * global.stage.height)) {
Main.overview.toggle();
}
- _setMoreCount(count) {
+ _setMoreCount(_count) {
}
_ensureResultActors(results, callback) {
this._dialog.open();
}
- close(op) {
+ close(_op) {
this._closeExistingDialog();
this._processesDialog = null;
* Closes a dialog previously opened by AskPassword, AskQuestion or ShowProcesses.
* If no dialog is open, does nothing.
*/
- Close(params, invocation) {
+ Close(_params, _invocation) {
this._clearCurrentRequest(Gio.MountOperationResult.UNHANDLED, {});
this._closeDialog();
}
return Clutter.EVENT_PROPAGATE;
}
- _moveHandle(absX, absY) {
+ _moveHandle(absX, _absY) {
let relX, sliderX;
[sliderX] = this.actor.get_transformed_position();
relX = absX - sliderX;
return false;
}
- _ibusSetContentType(im, purpose, hints) {
+ _ibusSetContentType(im, purpose, _hints) {
if (purpose == IBus.InputPurpose.PASSWORD) {
if (Object.keys(this._inputSources).length == Object.keys(this._ibusSources).length)
return;
this._sync();
}
- _connectionStateChanged(ac, newstate, reason) {
+ _connectionStateChanged(_ac, _newstate, _reason) {
this._sync();
}
return _("Connect");
}
- _connectionValid(connection) {
+ _connectionValid(_connection) {
return true;
}
this._client.activate_connection_async(connection, this._device, null, null, null);
}
- deactivateConnection(activeConnection) {
+ deactivateConnection(_activeConnection) {
this._device.disconnect(null);
}
this._source.notify(this._notification);
}
- _onActivationFailed(device, reason) {
+ _onActivationFailed(_device, _reason) {
// XXX: nm-applet has no special text depending on reason
// but I'm not sure of this generic message
this._notify('network-error-symbolic',
this._switcherList.allocate(childBox, flags);
}
- _initialSelection(backward, binding) {
+ _initialSelection(backward, _binding) {
if (backward)
this._select(this._items.length - 1);
else if (this._items.length == 1)
return mod(this._selectedIndex - 1, this._items.length);
}
- _keyPressHandler(keysym, action) {
+ _keyPressHandler(_keysym, _action) {
throw new GObject.NotImplementedError(`_keyPressHandler in ${this.constructor.name}`);
}
}
}
- _finish(timestamp) {
+ _finish(_timestamp) {
this.fadeAndDestroy();
}
return themeNode.adjust_preferred_width(maxChildMin, minListWidth);
}
- vfunc_get_preferred_height(forWidth) {
+ vfunc_get_preferred_height(_forWidth) {
let maxChildMin = 0;
let maxChildNat = 0;
});
}
- vfunc_gesture_prepare(actor) {
+ vfunc_gesture_prepare(_actor) {
return Main.actionMode == Shell.ActionMode.NORMAL &&
this.get_n_current_points() == this.get_n_touch_points();
}
height: maxY - minY });
}
- vfunc_gesture_begin(actor) {
+ vfunc_gesture_begin(_actor) {
this._initialRect = this._getBoundingRect(false);
return true;
}
- vfunc_gesture_end(actor) {
+ vfunc_gesture_end(_actor) {
let rect = this._getBoundingRect(true);
let oldArea = this._initialRect.width * this._initialRect.height;
let newArea = rect.width * rect.height;
GLib.Source.set_name_by_id(id, '[gnome-shell] this._queueCheckWorkspaces');
}
- _windowLeftMonitor(metaDisplay, monitorIndex, metaWin) {
+ _windowLeftMonitor(metaDisplay, monitorIndex, _metaWin) {
// If the window left the primary monitor, that
// might make that workspace empty
if (monitorIndex == Main.layoutManager.primaryIndex)
this._queueCheckWorkspaces();
}
- _windowEnteredMonitor(metaDisplay, monitorIndex, metaWin) {
+ _windowEnteredMonitor(metaDisplay, monitorIndex, _metaWin) {
// If the window entered the primary monitor, that
// might make that workspace non-empty
if (monitorIndex == Main.layoutManager.primaryIndex)
return (this._allowedModes & Main.actionMode);
}
- vfunc_gesture_progress(actor) {
+ vfunc_gesture_progress(_actor) {
let [x, y] = this.get_motion_coords(0);
let [xPress, yPress] = this.get_press_coords(0);
this.emit('motion', x - xPress, y - yPress);
return true;
}
- vfunc_gesture_cancel(actor) {
+ vfunc_gesture_cancel(_actor) {
if (!this._swept)
this.emit('cancel');
}
});
}
- vfunc_gesture_prepare(actor) {
+ vfunc_gesture_prepare(_actor) {
if (Main.actionMode != Shell.ActionMode.NORMAL) {
this.cancel();
return false;
return this.get_n_current_points() <= 4;
}
- vfunc_gesture_begin(actor) {
+ vfunc_gesture_begin(_actor) {
// in milliseconds
const LONG_PRESS_TIMEOUT = 250;
return this.get_n_current_points() <= 4;
}
- vfunc_gesture_progress(actor) {
+ vfunc_gesture_progress(_actor) {
const MOTION_THRESHOLD = 30;
if (this.get_n_current_points() == 3) {
}
}
- _sizeChangeWindow(shellwm, actor, whichChange, oldFrameRect, oldBufferRect) {
+ _sizeChangeWindow(shellwm, actor, whichChange, oldFrameRect, _oldBufferRect) {
let types = [Meta.WindowType.NORMAL];
if (!this._shouldAnimateActor(actor, types)) {
shellwm.completed_size_change(actor);
shellwm.completed_size_change(actor);
}
- _prepareAnimationInfo(shellwm, actor, oldFrameRect, change) {
+ _prepareAnimationInfo(shellwm, actor, oldFrameRect, _change) {
// Position a clone of the window on top of the old position,
// while actor updates are frozen.
let actorContent = Shell.util_get_content_for_window_actor(actor, oldFrameRect);
return box;
}
- vfunc_get_preferred_height(container, forWidth) {
+ vfunc_get_preferred_height(_container, _forWidth) {
return [this._boundingBox.height, this._boundingBox.height];
}
- vfunc_get_preferred_width(container, forHeight) {
+ vfunc_get_preferred_width(_container, _forHeight) {
return [this._boundingBox.width, this._boundingBox.width];
}
return true;
}
- _onDragBegin(draggable, time) {
+ _onDragBegin(_draggable, _time) {
this._dragSlot = this._slot;
[this.dragOrigX, this.dragOrigY] = this.get_position();
this.dragOrigScale = this.scale_x;
this._workspace.acceptDrop(source, actor, x, y, time);
}
- _onDragCancelled(draggable, time) {
+ _onDragCancelled(_draggable, _time) {
this.emit('drag-cancelled');
}
- _onDragEnd(draggable, time, snapback) {
+ _onDragEnd(_draggable, _time, _snapback) {
this.inDrag = false;
// We may not have a parent if DnD completed successfully, in
// row.width, row.height, row.fullWidth, row.fullHeight, and
// (optionally) for each row in @layout.rows. This method is
// intended to be called by subclasses.
- _computeRowSizes(layout) {
+ _computeRowSizes(_layout) {
throw new GObject.NotImplementedError(`_computeRowSizes in ${this.constructor.name}`);
}
// * gridWidth - The total width used by the grid, unscaled, unspaced.
// * gridHeight - The totial height used by the grid, unscaled, unspaced.
// * rows - A list of rows, which should be instantiated by _newRow.
- computeLayout(windows, layout) {
+ computeLayout(_windows, _layout) {
throw new GObject.NotImplementedError(`computeLayout in ${this.constructor.name}`);
}
}
// Draggable target interface
- handleDragOver(source, actor, x, y, time) {
+ handleDragOver(source, _actor, _x, _y, _time) {
if (source.realWindow && !this._isMyWindow(source.realWindow))
return DND.DragMotionResult.MOVE_DROP;
if (source.shellWorkspaceLaunch)
});
}
- _getPreferredSizeForOrientation(forSize) {
+ _getPreferredSizeForOrientation(_forSize) {
let workArea = Main.layoutManager.getWorkAreaForMonitor(Main.layoutManager.primaryIndex);
let themeNode = this.get_theme_node();
return Clutter.EVENT_STOP;
}
- _onDragBegin(draggable, time) {
+ _onDragBegin(_draggable, _time) {
this.inDrag = true;
this.emit('drag-begin');
}
- _onDragCancelled(draggable, time) {
+ _onDragCancelled(_draggable, _time) {
this.emit('drag-cancelled');
}
- _onDragEnd(draggable, time, snapback) {
+ _onDragEnd(_draggable, _time, _snapback) {
this.inDrag = false;
// We may not have a parent if DnD completed successfully, in
this._stateUpdateQueued = true;
}
- vfunc_get_preferred_height(forWidth) {
+ vfunc_get_preferred_height(_forWidth) {
// Note that for getPreferredWidth/Height we cheat a bit and skip propagating
// the size request to our children because we know how big they are and know
// that the actors aren't depending on the virtual functions being called.
this._indicator.allocate(childBox, flags);
}
- _activeWorkspaceChanged(wm, from, to, direction) {
+ _activeWorkspaceChanged(_wm, _from, _to, _direction) {
let thumbnail;
let workspaceManager = global.workspace_manager;
let activeWorkspace = workspaceManager.get_active_workspace();
this._syncActualGeometry();
}
- _activeWorkspaceChanged(wm, from, to, direction) {
+ _activeWorkspaceChanged(_wm, _from, _to, _direction) {
if (this._scrolling)
return;
projects / gnome-shell.git / commitdiff